import KeyChunkDao from "../dao/KeyChunkDao";
import { keyChunkStatus } from "../models/enums";
import ResultHelper from "../utils/ResultHelper";

export default class KeyChunkService {

  /**
   * 密钥块已经定义好，放在 Mysql
   */
  static async create() {
    /**
     * 前 4B 知道，意味着 前 32位 2进制知道，需要算后32位二进制数。
      64-8

      它们对应的10进制位 0~2^33-1

     */

    const unit = 2 ** 16
    const arr = []
    for (let i = 0; i < 2 ** 21; i += unit) {
      const start = i
      const end = start + unit

      arr.push(KeyChunkDao.create(start, end))
      // console.log(start, end, end - start);

      // arr.push(start)
      // arr.push(console.log(start, end, end - start));

    }
    // console.log(arr.length);
    // console.log('-----over----');
    // console.log(arr.length);

    Promise.all(arr).then(data => {
      console.log(data, data.length);
    })


    // KeyChunkDao.create()
  }

  /**
   * @params id 获取 密钥块 的节点计算机编码
   * @returns 
   */
  static async getOneUndistributed(id: any) {

    const result = await KeyChunkDao.getOneUndistributed()

    /* 
      TODO 查找成功后，需要修改 key chunk 的 status = 以分配，等待结果，并开启倒计时 自检程序，
      时间到后检查是否，收到结果，没有则 修改key chunk 的 status = 未分配。
    */

    // @ts-ignore
    if (result || result.id) {
      // @ts-ignore
      const keyChunkID = result.id
      this.putOneKey({
        id: keyChunkID,
        status: keyChunkStatus.await,
        reserve: JSON.stringify({ node_id: id })
      })
    }

    return ResultHelper.success(result ? result : [])
  }

  static async getRight() {
    let result = await KeyChunkDao.getRight()

    // 做过滤
    let data = result.data.map(item => {
      // @ts-ignore
      return JSON.parse(item.right)
    })

    // 扁平化
    data = data.flat()
    data = data.map(item => {
      return {
        number: item.number,
        result: item.result,
        hypothesisKey: item.hypothesisKey
      }
    })

    result.data = data

    return ResultHelper.success(result)
  }

  /**
   * 修改 一个密钥块的信息
   * @param data 
   * @returns 
   */
  static async putOneKey(data: {}) {
    try {
      const result = await KeyChunkDao.putOneKey(data)

      if (result) {
        return ResultHelper.success({}, "修改成功")
      } else {
        return ResultHelper.error("修改失败")
      }
    } catch (err) {
      console.log(err, 123);

    }
  }

  /**
   * 分页查找 密钥块
   * @param page 
   * @param limit 
   * @param options 
   * @returns 
   */
  static async findByPage(page: number = 1, limit: number = 10, options = {}) {
    const offset = (page - 1) * limit

    const result = await KeyChunkDao.findByPage(offset, limit, options)

    return ResultHelper.success(result)

  }




  // 统计 分配情况
  static async statusStatistics() {
    const result = await KeyChunkDao.statusStatistics()
    return ResultHelper.success(result)
  }

}